home *** CD-ROM | disk | FTP | other *** search
/ Over 1,000 Windows 95 Programs / Over 1000 Windows 95 Programs (Microforum) (Disc 1).iso / 1258 / samples / stockstr.jav < prev    next >
Text File  |  1996-05-05  |  7KB  |  294 lines
  1. /*
  2.  * @(#)StockStreamParser.java    1.10 95/12/09 Jim Graham
  3.  * 
  4.  * Copyright (c) 1994-1995 Sun Microsystems, Inc. All Rights Reserved.
  5.  *
  6.  * Permission to use, copy, modify, and distribute this software
  7.  * and its documentation for NON-COMMERCIAL or COMMERCIAL purposes and
  8.  * without fee is hereby granted. 
  9.  * Please refer to the file http://java.sun.com/copy_trademarks.html
  10.  * for further important copyright and trademark information and to
  11.  * http://java.sun.com/licensing.html for further important licensing
  12.  * information for the Java (tm) Technology.
  13.  * 
  14.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
  15.  * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
  16.  * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  17.  * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR
  18.  * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
  19.  * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
  20.  * 
  21.  * THIS SOFTWARE IS NOT DESIGNED OR INTENDED FOR USE OR RESALE AS ON-LINE
  22.  * CONTROL EQUIPMENT IN HAZARDOUS ENVIRONMENTS REQUIRING FAIL-SAFE
  23.  * PERFORMANCE, SUCH AS IN THE OPERATION OF NUCLEAR FACILITIES, AIRCRAFT
  24.  * NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL, DIRECT LIFE
  25.  * SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH THE FAILURE OF THE
  26.  * SOFTWARE COULD LEAD DIRECTLY TO DEATH, PERSONAL INJURY, OR SEVERE
  27.  * PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH RISK ACTIVITIES").  SUN
  28.  * SPECIFICALLY DISCLAIMS ANY EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR
  29.  * HIGH RISK ACTIVITIES.
  30.  */
  31.  
  32. import java.io.InputStream;
  33. import java.io.BufferedInputStream;
  34. import java.io.IOException;
  35. import java.io.StreamTokenizer;
  36. import java.util.Vector;
  37. import java.util.StringTokenizer;
  38. import java.net.URL;
  39. import java.awt.Color;
  40.  
  41. /**
  42.  * A simple class to read a stock quote data stream and execute callbacks
  43.  * on the (StockWatcher) parent with the parsed data.
  44.  *
  45.  * @author    Jim Graham
  46.  * @version     1.10, 12/09/95
  47.  */
  48. public class StockStreamParser implements Runnable {
  49.     int numURLs;
  50.     String dataURLs[];
  51.     boolean isStatic[];
  52.  
  53.     String stocks;
  54.  
  55.     StockWatcher watcher;
  56.     URL documentURL;
  57.  
  58.     boolean canFudge;
  59.     int delay;
  60.     int history;
  61.  
  62.     URL dataURL;
  63.     InputStream dataStream;
  64.     Thread kicker;
  65.  
  66.     public StockStreamParser(StockWatcher parent, URL docURL,
  67.                  boolean fudge, int d, int h) {
  68.     watcher = parent;
  69.     documentURL = docURL;
  70.     canFudge = fudge;
  71.     delay = d;
  72.     history = h;
  73.  
  74.     Vector URLlist = new Vector();
  75.     String URLs = parent.getParameter("livedata");
  76.     int numLive = 0;
  77.     if (URLs != null) {
  78.         StringTokenizer st = new StringTokenizer(URLs, "|");
  79.         while (st.hasMoreTokens()) {
  80.         String nextURL = (String) st.nextToken();
  81.         URLlist.addElement(nextURL);
  82.         numLive++;
  83.         }
  84.     }
  85.     URLs = parent.getParameter("staticdata");
  86.     int numStatic = 0;
  87.     if (URLs != null) {
  88.         StringTokenizer st = new StringTokenizer(URLs, "|");
  89.         while (st.hasMoreTokens()) {
  90.         String nextURL = (String) st.nextToken();
  91.         URLlist.addElement(nextURL);
  92.         numStatic++;
  93.         }
  94.     }
  95.     if (numLive == 0 && numStatic == 0) {
  96.         URLs = parent.getParameter("data");
  97.         if (URLs == null) {
  98.         URLs = "http://benden:8888/stock.dat";
  99.         }
  100.         URLlist.addElement(URLs);
  101.         String s = parent.getParameter("static");
  102.         if (s != null && s.equals("true")) {
  103.         numStatic = 1;
  104.         } else {
  105.         numLive = 1;
  106.         }
  107.     }
  108.     numURLs = numLive + numStatic;
  109.     isStatic = new boolean[numURLs];
  110.     for (int i = 0; i < numURLs; i++) {
  111.         isStatic[i] = (i >= numLive);
  112.     }
  113.     dataURLs = new String[numURLs];
  114.     URLlist.copyInto(dataURLs);
  115.     }
  116.  
  117.     public void setStock(String stock) {
  118.     stocks = "/" + stock;
  119.     }
  120.  
  121.     public void setStock(String stock[]) {
  122.     stocks = "";
  123.     for (int i = 0; i < stock.length; i++) {
  124.         stocks += "/" + stock[i];
  125.     }
  126.     }
  127.  
  128.     public void run() {
  129.     int index = 0;
  130.     boolean done = false;
  131.     while (kicker != null && !done) {
  132.         try {
  133.         String sendURL;
  134.         if (isStatic[index]) {
  135.             sendURL = dataURLs[index];
  136.             int percent = sendURL.indexOf("%");
  137.             if (percent >= 0) {
  138.             sendURL = sendURL.substring(0, percent) + stocks;
  139.             }
  140.         } else {
  141.             sendURL = dataURLs[index]
  142.             + stocks
  143.             + (canFudge ? "?f" : "?")
  144.             + ((history == 0)
  145.                ? ("dle," + delay)
  146.                : ("dhle," + delay + "," + history + "s"));
  147.         }
  148.         dataURL = new URL(documentURL, sendURL);
  149.         dataStream = new BufferedInputStream(dataURL.openStream());
  150.         done = true;
  151.         readStream(dataStream);
  152.         } catch(ThreadDeath td) {
  153.         done = true;
  154.         } catch(IOException e) {
  155.         //} catch(Exception e) {
  156.         //e.printStackTrace();
  157.         //close();
  158.         //throw e;
  159.         }
  160.         close();
  161.         if (!done) {
  162.         index++;
  163.         if (index == numURLs) {
  164.             index = 0;
  165.             try {
  166.             Thread.sleep(5000);
  167.             } catch (InterruptedException e) {
  168.             done = true;
  169.             }
  170.         }
  171.         }
  172.     }
  173.     watcher.feedEOF(this);
  174.     System.out.println("Exitting");
  175.     }
  176.  
  177.     public void start() {
  178.     kicker = new Thread(this);
  179.     kicker.setPriority(Thread.MIN_PRIORITY);
  180.     kicker.start();
  181.     }
  182.  
  183.     public void stop() {
  184.     Thread t = kicker;
  185.     kicker = null;
  186.     t.stop();
  187.     close();
  188.     }
  189.  
  190.     public synchronized void close() {
  191.     try {
  192.         dataStream.close();
  193.     } catch (Exception e) {
  194.     }
  195.     dataStream = null;
  196.     }
  197.  
  198.     private static final int IGNORE = 0;
  199.     private static final int QUOTE = 1;
  200.     private static final int HIGH = 2;
  201.     private static final int LOW = 3;
  202.     private static final int CLOSE = 4;
  203.     private static final int HIST_TIME = 5;
  204.     private static final int HIST_VAL = 6;
  205.     private static final int ERROR = 7;
  206.  
  207.     public void readStream(InputStream dataStream) throws IOException {
  208.     StreamTokenizer st = new StreamTokenizer(dataStream);
  209.     st.eolIsSignificant(false);
  210.     int nextval = IGNORE;
  211.     int histTime = 0;
  212.     String symbol = null;
  213.     while (kicker != null) {
  214.         if (dataStream.available() < 1) {
  215.         watcher.flushQuotes();
  216.         }
  217.         int tok = st.nextToken();
  218.         if (kicker == null) {
  219.         break;
  220.         }
  221.         switch (tok) {
  222.           case st.TT_EOF:
  223.         System.out.println("EOF "+stocks);
  224.         return;
  225.           case st.TT_NUMBER:
  226.         switch (nextval) {
  227.         case HIGH:
  228.             watcher.newHigh(symbol, st.nval);
  229.             break;
  230.         case LOW:
  231.             watcher.newLow(symbol, st.nval);
  232.             break;
  233.         case CLOSE:
  234.             watcher.newClose(symbol, st.nval);
  235.             break;
  236.         case HIST_TIME:
  237.             histTime = (int) st.nval;
  238.             nextval = HIST_VAL;
  239.             continue;
  240.         case HIST_VAL:
  241.             watcher.newQuote(symbol, st.nval, histTime);
  242.             break;
  243.         case QUOTE:
  244.             watcher.newQuote(symbol, st.nval);
  245.             break;
  246.         default:
  247.             System.out.println("Ignoring "+st.nval);
  248.             break;
  249.         }
  250.         nextval = IGNORE;
  251.         break;
  252.           case st.TT_WORD:
  253.         symbol = st.sval;
  254.         if (nextval == ERROR) {
  255.             watcher.setFeedError(symbol, true);
  256.             nextval = IGNORE;
  257.         } else {
  258.             if (nextval == IGNORE) {
  259.             nextval = QUOTE;
  260.             }
  261.             watcher.setFeedError(symbol, false);
  262.         }
  263.         break;
  264.           default:
  265.         int prefix = st.ttype;
  266.         switch (prefix) {
  267.         case '^':
  268.             nextval = HIGH;
  269.             break;
  270.         case '_':
  271.             nextval = LOW;
  272.             break;
  273.         case '<':
  274.             nextval = CLOSE;
  275.             break;
  276.         case '#':
  277.             nextval = ERROR;
  278.             break;
  279.         case '@':
  280.             nextval = HIST_TIME;
  281.             break;
  282.         case '*':
  283.             // Server side fudge indicator - ignore it...
  284.             break;
  285.         default:
  286.             System.out.println("Unknown quote token: "+st);
  287.             break;
  288.         }
  289.         break;
  290.         }
  291.     }
  292.     }
  293. }
  294.